from xen.xend import scheduler
from xen.xend.server import channel
from xen.xend.server import relocate
-from xen.xend import XendDB
+from xen.xend.uuid import getUuid
+from xen.xend.xenstore import XenNode, DBMap
__all__ = [ "XendDomain" ]
"""Index of all domains. Singleton.
"""
- """Path to domain database."""
- dbpath = "domain"
-
"""Dict of domain info indexed by domain id."""
domains = None
# So we stuff the XendDomain instance (self) into xroot's components.
xroot.add_component("xen.xend.XendDomain", self)
self.domains = XendDomainDict()
- self.db = XendDB.XendDB(self.dbpath)
+ self.dbmap = DBMap(db=XenNode("/domain"))
eserver.subscribe('xend.virq', self.onVirq)
self.initial_refresh()
"""Refresh initial domain info from db.
"""
doms = self.xen_domains()
- for config in self.db.fetchall("").values():
- domid = int(sxp.child_value(config, 'id'))
- if domid in doms:
+ self.dbmap.readDB()
+ for domdb in self.dbmap.values():
+ try:
+ domid = int(domdb.id)
+ except:
+ domid = None
+ # XXX if domid in self.domains, then something went wrong
+ if (domid is None) or (domid in self.domains):
+ domdb.delete()
+ elif domid in doms:
try:
- self._new_domain(config, doms[domid])
+ self._new_domain(domdb, doms[domid])
except Exception, ex:
log.exception("Error recreating domain info: id=%d", domid)
self._delete_domain(domid)
self._delete_domain(domid)
self.refresh(cleanup=True)
- def sync_domain(self, info):
- """Sync info for a domain to disk.
-
- info domain info
- """
- self.db.save(str(info.id), info.sxpr())
-
def close(self):
pass
- def _new_domain(self, savedinfo, info):
+ def _new_domain(self, db, info):
"""Create a domain entry from saved info.
- @param savedinfo: saved info from the db
+ @param db: saved info from the db
@param info: domain info from xen
@return: domain
"""
- uuid = sxp.child_value(savedinfo, 'uuid')
- dominfo = XendDomainInfo.recreate(savedinfo, info, uuid)
+ log.error(db)
+ log.error(db.uuid)
+ dominfo = XendDomainInfo.recreate(db, info)
self.domains[dominfo.id] = dominfo
- self.sync_domain(dominfo)
return dominfo
def _add_domain(self, info, notify=True):
for i, d in self.domains.items():
if i != d.id:
del self.domains[i]
- self.db.delete(str(i))
+ self.dbmap.delete(d.uuid)
if info.id in self.domains:
notify = False
self.domains[info.id] = info
- self.sync_domain(info)
+ info.exportToDB(save=True)
if notify:
eserver.inject('xend.domain.create', [info.name, info.id])
@param id: domain id
@param notify: send a domain died event if true
"""
+ try:
+ if self.xen_domain(id):
+ return
+ except:
+ pass
info = self.domains.get(id)
if info:
del self.domains[id]
- self.db.delete(str(id))
+ info.cleanup()
+ info.delete()
if notify:
eserver.inject('xend.domain.died', [info.name, info.id])
+ # XXX this should not be needed
+ for domdb in self.dbmap.values():
+ try:
+ domid = int(domdb.id)
+ except:
+ domid = None
+ if (domid is None) or (domid == id):
+ domdb.delete()
def reap(self):
"""Look for domains that have crashed or stopped.
@param config: configuration
@return: domain
"""
- dominfo = XendDomainInfo.create(config)
- self._add_domain(dominfo)
+ dominfo = XendDomainInfo.create(self.dbmap, config)
return dominfo
def domain_restart(self, dominfo):
[dominfo.name, dominfo.id, "begin"])
try:
dominfo.restart()
- self._add_domain(dominfo)
log.info('Restarted domain name=%s id=%s', dominfo.name, dominfo.id)
eserver.inject("xend.domain.restart",
[dominfo.name, dominfo.id, "success"])
"""
config = sxp.child_value(vmconfig, 'config')
uuid = sxp.child_value(vmconfig, 'uuid')
- dominfo = XendDomainInfo.restore(config, uuid=uuid)
- self._add_domain(dominfo)
+ dominfo = XendDomainInfo.restore(self.dbmap, config, uuid=uuid)
return dominfo
def domain_restore(self, src, progress=False):
try:
info = self.xen_domain(id)
if info:
- log.info("Creating entry for unknown domain: id=%d", id)
- dominfo = XendDomainInfo.recreate(None, info)
+ uuid = getUuid()
+ log.info(
+ "Creating entry for unknown domain: id=%d uuid=%s",
+ id, uuid)
+ db = self.dbmap.addChild(uuid)
+ dominfo = XendDomainInfo.recreate(db, info)
self._add_domain(dominfo)
except Exception, ex:
log.exception("Error creating domain info: id=%d", id)
"""
dominfo = self.domain_lookup(id)
val = dominfo.device_create(devconfig)
- self.sync_domain(dominfo)
+ dominfo.exportToDB()
return val
def domain_device_configure(self, id, devconfig, devid):
"""
dominfo = self.domain_lookup(id)
val = dominfo.device_configure(devconfig, devid)
- self.sync_domain(dominfo)
+ dominfo.exportToDB()
return val
def domain_device_refresh(self, id, type, devid):
"""
dominfo = self.domain_lookup(id)
val = dominfo.device_refresh(type, devid)
- self.sync_domain(dominfo)
+ dominfo.exportToDB()
return val
def domain_device_destroy(self, id, type, devid):
"""
dominfo = self.domain_lookup(id)
val = dominfo.device_destroy(type, devid)
- self.sync_domain(dominfo)
+ dominfo.exportToDB()
return val
def domain_devtype_ls(self, id, type):
from xen.xend.XendRoot import get_component
from xen.xend.uuid import getUuid
+from xen.xend.xenstore import DBVar
"""Flag for a block device backend domain."""
SIF_BLK_BE_DOMAIN = (1<<4)
"""
MINIMUM_RESTART_TIME = 20
- def _create(cls, uuid=None):
- """Create a vm object with a uuid.
-
- @param uuid uuid to use
- @return vm
- """
- if uuid is None:
- uuid = getUuid()
- vm = cls()
- vm.uuid = uuid
- return vm
-
- _create = classmethod(_create)
-
- def create(cls, config):
+ def create(cls, parentdb, config):
"""Create a VM from a configuration.
- If a vm has been partially created and there is an error it
- is destroyed.
+ @param parentdb: parent db
@param config configuration
@raise: VmError for invalid configuration
"""
- vm = cls._create()
+ uuid = getUuid()
+ db = parentdb.addChild(uuid)
+ vm = cls(db)
vm.construct(config)
+ vm.saveDB(sync=True)
return vm
create = classmethod(create)
- def recreate(cls, savedinfo, info, uuid=None):
+ def recreate(cls, db, info):
"""Create the VM object for an existing domain.
- @param savedinfo: saved info from the domain DB
+ @param db: domain db
@param info: domain info from xc
- @param uuid: uuid to use
- @type info: xc domain dict
"""
- vm = cls._create(uuid=uuid)
-
- log.debug('savedinfo=' + prettyprintstring(savedinfo))
+ dom = info['dom']
+ vm = cls(db)
+ db.readDB()
+ vm.importFromDB()
+ config = vm.config
log.debug('info=' + str(info))
+ log.debug('config=' + prettyprintstring(config))
- vm.recreate = True
- vm.savedinfo = savedinfo
- vm.setdom(info['dom'])
+ vm.setdom(dom)
vm.memory = info['mem_kb']/1024
- start_time = sxp.child_value(savedinfo, 'start_time')
- if start_time is not None:
- vm.start_time = float(start_time)
- vm.restart_state = sxp.child_value(savedinfo, 'restart_state')
- vm.restart_count = int(sxp.child_value(savedinfo, 'restart_count', 0))
- restart_time = sxp.child_value(savedinfo, 'restart_time')
- if restart_time is not None:
- vm.restart_time = float(restart_time)
- config = sxp.child_value(savedinfo, 'config')
-
if config:
- vm.construct(config)
+ try:
+ vm.recreate = True
+ vm.construct(config)
+ finally:
+ vm.recreate = False
else:
- vm.setName(sxp.child_value(savedinfo, 'name',
- "Domain-%d" % info['dom']))
- vm.recreate = False
- vm.savedinfo = None
+ vm.setName("Domain-%d" % dom)
+ vm.exportToDB(save=True)
return vm
recreate = classmethod(recreate)
- def restore(cls, config, uuid=None):
+ def restore(cls, parentdb, config, uuid=None):
"""Create a domain and a VM object to do a restore.
+ @param parentdb: parent db
@param config: domain configuration
@param uuid: uuid to use
"""
- vm = cls._create(uuid=uuid)
+ db = parentdb.addChild(uuid)
+ vm = cls(db)
dom = xc.domain_create()
vm.setdom(dom)
vm.dom_construct(vm.id, config)
+ vm.saveDB(sync=True)
return vm
restore = classmethod(restore)
- def __init__(self):
+ __exports__ = [
+ DBVar('id', ty='str'),
+ DBVar('name', ty='str'),
+ DBVar('uuid', ty='str'),
+ DBVar('config', ty='sxpr'),
+ DBVar('start_time', ty='float'),
+ DBVar('state', ty='str'),
+ DBVar('store_mfn', ty='long'),
+ DBVar('restart_mode', ty='str'),
+ DBVar('restart_state', ty='str'),
+ DBVar('restart_time', ty='float'),
+ DBVar('restart_count', ty='int'),
+ ]
+
+ def __init__(self, db):
+ self.db = db
+ self.uuid = db.getName()
+
self.recreate = 0
self.restore = 0
self.config = None
- self.uuid = None
self.id = None
self.cpu_weight = 1
self.start_time = None
self.restart_count = 0
self.console_port = None
- self.savedinfo = None
self.vcpus = 1
self.bootloader = None
+ def setDB(self, db):
+ self.db = db
+
+ def saveDB(self, save=False, sync=False):
+ self.db.saveDB(save=save, sync=sync)
+
+ def exportToDB(self, save=False, sync=False):
+ if self.channel:
+ self.channel.saveToDB(self.db.addChild("channel"))
+ if self.store_channel:
+ self.store_channel.saveToDB(self.db.addChild("store_channel"))
+ self.db.exportToDB(self, fields=self.__exports__, save=save, sync=sync)
+
+ def importFromDB(self):
+ self.db.importFromDB(self, fields=self.__exports__)
+
def setdom(self, dom):
"""Set the domain id.
@param dom: domain id
"""
self.id = int(dom)
+ #self.db.id = self.id
def getDomain(self):
return self.id
def setName(self, name):
self.name = name
- #self.db.name = self.name
+ self.db.name = self.name
def getName(self):
return self.name
self.state = state
self.state_updated.notifyAll()
self.state_updated.release()
+ self.saveDB()
def state_wait(self, state):
self.state_updated.acquire()
self.configure_restart()
self.construct_image()
self.configure()
+ self.exportToDB()
except Exception, ex:
# Catch errors, cleanup and re-raise.
print 'Domain construction error:', ex
def register_domain(self):
xd = get_component('xen.xend.XendDomain')
xd._add_domain(self)
+ self.exportToDB()
def configure_cpus(self, config):
try:
"""
self.create_channel()
self.image.createImage()
- #self.image.exportToDB()
+ self.image.exportToDB()
#if self.store_channel:
# self.db.introduceDomain(self.id,
# self.store_mfn,
# self.store_channel)
- def get_device_savedinfo(self, type, id):
- val = None
- if self.savedinfo is None:
- return val
- devices = sxp.child(self.savedinfo, 'devices')
- if devices is None:
- return val
- for d in sxp.children(devices, type):
- did = sxp.child_value(d, 'id')
- if did is None: continue
- if int(did) == id:
- val = d
- break
- return val
-
- def get_device_recreate(self, type, id):
- return self.get_device_savedinfo(type, id) or self.recreate
-
- def destroy(self):
- """Completely destroy the vm.
+ def delete(self):
+ """Delete the vm's db.
"""
+ if self.dom_get(self.id):
+ return
+ self.id = None
+ self.saveDB(sync=True)
try:
- self.cleanup()
- except Exception, ex:
- log.warning("error in domain cleanup: %s", ex)
- pass
- try:
- self.destroy_domain()
+ # Todo: eventually will have to wait for devices to signal
+ # destruction before can delete the db.
+ if self.db:
+ self.db.delete()
except Exception, ex:
- log.warning("error in domain destroy: %s", ex)
+ log.warning("error in domain db delete: %s", ex)
pass
def destroy_domain(self):
The domain will not finally go away unless all vm
devices have been released.
"""
+ if self.id is None:
+ return
+ try:
+ xc.domain_destroy(dom=self.id)
+ except Exception, err:
+ log.exception("Domain destroy failed: %s", self.name)
+
+ def cleanup(self):
+ """Cleanup vm resources: release devices.
+ """
+ self.state = STATE_VM_TERMINATED
+ self.release_devices()
if self.channel:
try:
self.channel.close()
self.store_channel = None
except:
pass
+ #try:
+ # self.db.releaseDomain(self.id)
+ #except Exception, ex:
+ # log.warning("error in domain release on xenstore: %s", ex)
+ # pass
if self.image:
try:
self.image.destroy()
self.image = None
except:
pass
- if self.id is None: return 0
- try:
- xc.domain_destroy(dom=self.id)
- except Exception, err:
- log.exception("Domain destroy failed: %s", self.name)
- def cleanup(self):
- """Cleanup vm resources: release devices.
+ def destroy(self):
+ """Clenup vm and destroy domain.
"""
- self.state = STATE_VM_TERMINATED
- self.release_devices()
+ self.cleanup()
+ self.destroy_domain()
+ self.saveDB()
+ return 0
def is_terminated(self):
"""Check if a domain has been terminated.
if not self.restore:
self.setdom(dom)
- def openChannel(self, name, local, remote):
+ def openChannel(self, key, local, remote):
"""Create a channel to the domain.
If saved info is available recreate the channel.
+ @param key db key for the saved data (if any)
@param local default local port
@param remote default remote port
"""
- local = 0
- remote = 1
- if self.savedinfo:
- info = sxp.child(self.savedinfo, name)
- if info:
- local = int(sxp.child_value(info, "local_port", 0))
- remote = int(sxp.child_value(info, "remote_port", 1))
- chan = channelFactory().openChannel(self.id, local_port=local,
- remote_port=remote)
+ db = self.db.addChild(key)
+ chan = channelFactory().restoreFromDB(db, self.id, local, remote)
+ #todo: save here?
+ #chan.saveToDB(db)
return chan
- def eventChannel(self, name):
- return EventChannel.interdomain(0, self.id)
-
+ def eventChannel(self, key):
+ db = self.db.addChild(key)
+ return EventChannel.restoreFromDB(db, 0, self.id)
+
def create_channel(self):
"""Create the channels to the domain.
"""
if self.bootloader:
self.config = self.bootloader_config()
self.construct(self.config)
+ self.saveDB()
finally:
self.restart_state = None
class XendRoot:
"""Root of the management classes."""
- """Default path to the root of the database."""
- dbroot_default = "/var/lib/xen/xend-db"
-
"""Default path to the config file."""
config_default = "/etc/xen/xend-config.sxp"
components = {}
def __init__(self):
- self.dbroot = None
self.config_path = None
self.config = None
self.logging = None
def configure(self):
self.set_config()
self.configure_logger()
- self.dbroot = self.get_config_value("dbroot", self.dbroot_default)
def configure_logger(self):
logfile = self.get_config_value("logfile", self.logfile_default)
"""
return self.logging and self.logging.getLogger()
- def get_dbroot(self):
- """Get the path to the database root.
- """
- return self.dbroot
-
def set_config(self):
"""If the config file exists, read it. If not, ignore it.
"""
from xen.util import Brctl
-
-import sxp
-import XendDB
-from XendError import XendError
-from XendLogging import log
+from xen.xend import sxp
+from xen.xend.XendError import XendError
+from xen.xend.XendLogging import log
+from xen.xend.xenstore import XenNode, DBMap
def vnet_cmd(cmd):
out = None
"""Index of all vnets. Singleton.
"""
- dbpath = "vnet"
+ dbpath = "/vnet"
def __init__(self):
# Table of vnet info indexed by vnet id.
self.vnet = {}
- self.db = XendDB.XendDB(self.dbpath)
- vnets = self.db.fetchall("")
- for config in vnets.values():
+ self.dbmap = DBMap(db=XenNode(self.dbpath))
+ self.dbmap.readDB()
+ for vnetdb in self.dbmap.values():
+ config = vnetdb.config
info = XendVnetInfo(config)
self.vnet[info.id] = info
try:
"""
info = XendVnetInfo(config)
self.vnet[info.id] = info
- self.db.save(info.id, info.sxpr())
+ self.dbmap["%s/config" % info.id] = info.sxpr()
info.configure()
def vnet_delete(self, id):
info = self.vnet_get(id)
if info:
del self.vnet[id]
- self.db.delete(id)
+ self.dbmap.delete(id)
info.delete()
def instance():
from xen.xend import sxp
from xen.xend.XendError import VmError
from xen.xend.XendLogging import log
-#from xen.xend.xenstore import DBVar
+from xen.xend.xenstore import DBVar
class ImageHandler:
"""Abstract base class for image handlers.
#======================================================================
# Instance vars and methods.
- #db = None
+ db = None
ostype = None
config = None
cmdline = None
flags = 0
- #__exports__ = [
- # DBVar('ostype', ty='str'),
- # DBVar('config', ty='sxpr'),
- # DBVar('kernel', ty='str'),
- # DBVar('ramdisk', ty='str'),
- # DBVar('cmdline', ty='str'),
- # DBVar('flags', ty='int'),
- # ]
+ __exports__ = [
+ DBVar('ostype', ty='str'),
+ DBVar('config', ty='sxpr'),
+ DBVar('kernel', ty='str'),
+ DBVar('ramdisk', ty='str'),
+ DBVar('cmdline', ty='str'),
+ DBVar('flags', ty='int'),
+ ]
def __init__(self, vm, config):
self.vm = vm
- #self.db = vm.db.addChild('/image')
+ self.db = vm.db.addChild('/image')
self.config = config
- #def exportToDB(self, save=False):
- # self.db.exportToDB(self, fields=self.__exports__, save=save)
+ def exportToDB(self, save=False):
+ self.db.exportToDB(self, fields=self.__exports__, save=save)
- #def importFromDB(self):
- # self.db.importFromDB(self, fields=self.__exports__)
+ def importFromDB(self):
+ self.db.importFromDB(self, fields=self.__exports__)
def unlink(self, f):
if not f: return
class VmxImageHandler(ImageHandler):
- #__exports__ = ImageHandler.__exports__ + [
- # DBVar('memmap', ty='str'),
- # DBVar('memmap_value', ty='sxpr'),
- # # device channel?
- # ]
+ __exports__ = ImageHandler.__exports__ + [
+ DBVar('memmap', ty='str'),
+ DBVar('memmap_value', ty='sxpr'),
+ # device channel?
+ ]
ostype = "vmx"
memmap = None
from xen.xend.XendLogging import log
from xen.xend import sxp
from xen.xend import Blkctl
+from xen.xend.xenstore import DBVar
from xen.xend.server import channel
from xen.xend.server.controller import CtrlMsgRcvr, Dev, DevController
"""Info record for a block device.
"""
+ __exports__ = Dev.__exports__ + [
+ DBVar('dev', ty='str'),
+ DBVar('vdev', ty='int'),
+ DBVar('mode', ty='str'),
+ DBVar('viftype', ty='str'),
+ DBVar('params', ty='str'),
+ DBVar('node', ty='str'),
+ DBVar('device', ty='long'),
+ DBVar('start_sector', ty='long'),
+ DBVar('nr_sectors', ty='long'),
+ ]
+
def __init__(self, controller, id, config, recreate=False):
Dev.__init__(self, controller, id, config, recreate=recreate)
self.dev = None
def attach(self, recreate=False, change=False):
if recreate:
- node = sxp.child_value(recreate, 'node')
- self.setNode(node)
+ pass
else:
node = Blkctl.block('bind', self.type, self.params)
self.setNode(node)
return self.controller.getBackend(self.backendDomain)
def refresh(self):
- log.debug("Refreshing vbd domain=%d id=%s", self.frontendDomain, self.id)
+ log.debug("Refreshing vbd domain=%d id=%s", self.frontendDomain,
+ self.id)
self.interfaceChanged()
def destroy(self, change=False, reboot=False):
@param change: change flag
"""
self.destroyed = True
- log.debug("Destroying vbd domain=%d id=%s", self.frontendDomain, self.id)
+ log.debug("Destroying vbd domain=%d id=%s", self.frontendDomain,
+ self.id)
self.send_be_vbd_destroy()
if change:
self.interfaceChanged()
log.error("Exception connecting backend: %s", ex)
else:
log.error('interface connect on unknown interface: id=%d', id)
-
interdomain = classmethod(interdomain)
+ def restoreFromDB(cls, db, dom1, dom2, port1=0, port2=0):
+ """Create an event channel using db info if available.
+ Inverse to saveToDB().
+
+ @param db db
+ @param dom1
+ @param dom2
+ @param port1
+ @param port2
+ """
+ try:
+ dom1 = int(db['dom1'])
+ except: pass
+ try:
+ dom2 = int(db['dom2'])
+ except: pass
+ try:
+ port1 = int(db['port1'])
+ except: pass
+ try:
+ port2 = int(db['port2'])
+ except: pass
+ evtchn = cls.interdomain(dom1, dom2, port1=port1, port2=port2)
+ return evtchn
+
+ restoreFromDB = classmethod(restoreFromDB)
+
def __init__(self, dom1, dom2, d):
d['dom1'] = dom1
d['dom2'] = dom2
evtchn_close(self.dom1, self.port1)
evtchn_close(self.dom2, self.port2)
+ def saveToDB(self, db):
+ """Save the event channel to the db so it can be restored later,
+ using restoreFromDB() on the class.
+
+ @param db db
+ """
+ db['dom1'] = str(self.dom1)
+ db['dom2'] = str(self.dom2)
+ db['port1'] = str(self.port1)
+ db['port2'] = str(self.port2)
+ db.saveDB()
+
def sxpr(self):
return ['event-channel',
['dom1', self.dom1 ],
]
def __repr__(self):
- return ("<EventChannel dom1:%s:%s dom2:%s:%s>"
+ return ("<EventChannel dom1:%d:%d dom2:%d:%d>"
% (self.dom1, self.port1, self.dom2, self.port2))
def eventChannel(dom1, dom2, port1=0, port2=0):
@type remote: int
@return: port object
"""
- return xu.port(dom, local_port=int(local_port),
- remote_port=int(remote_port))
+ return xu.port(dom, local_port=local_port, remote_port=remote_port)
+
+ def restoreFromDB(self, db, dom, local, remote):
+ """Create a channel using ports restored from the db (if available).
+ Otherwise use the given ports. This is the inverse operation to
+ saveToDB() on a channel.
+
+ @param db db
+ @param dom domain the channel connects to
+ @param local default local port
+ @param remote default remote port
+ """
+ try:
+ local_port = int(db['local_port'])
+ except:
+ local_port = local
+ try:
+ remote_port = int(db['remote_port'])
+ except:
+ remote_port = remote
+ try:
+ chan = self.openChannel(dom, local_port, remote_port)
+ except:
+ return None
+ return chan
def channelFactory():
"""Singleton constructor for the channel factory.
# Make sure the port will deliver all the messages.
self.port.register(TYPE_WILDCARD)
+ def saveToDB(self, db):
+ """Save the channel ports to the db so the channel can be restored later,
+ using restoreFromDB() on the factory.
+
+ @param db db
+ """
+ if self.closed: return
+ db['local_port'] = str(self.getLocalPort())
+ db['remote_port'] = str(self.getRemotePort())
+ db.saveDB()
+
def getKey(self):
"""Get the channel key.
"""
from xen.xend.XendLogging import log
from xen.xend import XendRoot; xroot = XendRoot.instance()
from xen.xend import sxp
+from xen.xend.xenstore import DBVar
from xen.xend.server.controller import CtrlMsgRcvr, Dev, DevController
from xen.xend.server.messages import *
STATUS_CONNECTED = 'connected'
STATUS_LISTENING = 'listening'
+ __exports__ = Dev.__exports__ + [
+ DBVar('status', ty='str'),
+ #DBVar('listening', ty='str'),
+ DBVar('console_port', ty='int'),
+ ]
+
def __init__(self, controller, id, config, recreate=False):
Dev.__init__(self, controller, id, config)
self.lock = threading.RLock()
"""
from xen.xend.XendError import XendError
+from xen.xend.xenstore import DBVar
from xen.xend.server.messages import msgTypeName, printMsg, getMessageType
DEBUG = 0
"""
+ # State:
+ # controller/<type> : for controller
+ # device/<type>/<id> : for each device
+
def createDevController(cls, vm, recreate=False):
"""Class method to create a dev controller.
"""
ctrl = cls(vm, recreate=recreate)
ctrl.initController(recreate=recreate)
+ ctrl.exportToDB()
return ctrl
createDevController = classmethod(createDevController)
getType = classmethod(getType)
+ __exports__ = [
+ DBVar('type', 'str'),
+ DBVar('destroyed', 'bool'),
+ ]
+
# Set when registered.
type = None
def __init__(self, vm, recreate=False):
self.destroyed = False
self.vm = vm
+ self.db = self.getDB()
self.deviceId = 0
self.devices = {}
self.device_order = []
+ def getDB(self):
+ """Get the db node to use for a controller.
+ """
+ return self.vm.db.addChild("/controller/%s" % self.getType())
+
+ def getDevDB(self, id):
+ """Get the db node to use for a device.
+ """
+ return self.vm.db.addChild("/device/%s/%s" % (self.getType(), id))
+
+ def exportToDB(self, save=False):
+ self.db.exportToDB(self, fields=self.__exports__, save=save)
+
+ def importFromDB(self):
+ self.db.importFromDB(self, fields=self.__exports__)
+
def getDevControllerType(self):
return self.dctype
If change is true the device is a change to an existing domain,
i.e. it is being added at runtime rather than when the domain is created.
"""
- # skanky hack: we use the device ids to maybe find the savedinfo
- # of the device...
- id = self.nextDeviceId()
- if recreate:
- recreate = self.vm.get_device_savedinfo(self.getType(), id)
- dev = self.newDevice(id, config, recreate=recreate)
+ dev = self.newDevice(self.nextDeviceId(), config, recreate=recreate)
+ if self.vm.recreate:
+ dev.importFromDB()
dev.init(recreate=recreate)
self.addDevice(dev)
+ if not recreate:
+ dev.exportToDB()
dev.attach(recreate=recreate, change=change)
+ dev.exportToDB()
def configureDevice(self, id, config, change=False):
"""Reconfigure an existing device.
@type controller: DevController
"""
+ # ./status : need 2: actual and requested?
+ # down-down: initial.
+ # up-up: fully up.
+ # down-up: down requested, still up. Watch front and back, when both
+ # down go to down-down. But what if one (or both) is not connected?
+ # Still have front/back trees with status? Watch front/status, back/status?
+ # up-down: up requested, still down.
+ # Back-end watches ./status, front/status
+ # Front-end watches ./status, back/status
+ # i.e. each watches the other 2.
+ # Each is status/request status/actual?
+ #
+ # backend?
+ # frontend?
+
+ __exports__ = [
+ DBVar('id', ty='int'),
+ DBVar('type', ty='str'),
+ DBVar('config', ty='sxpr'),
+ DBVar('destroyed', ty='bool'),
+ ]
+
def __init__(self, controller, id, config, recreate=False):
self.controller = controller
self.id = id
self.config = config
self.destroyed = False
+ self.type = self.getType()
+
+ self.db = controller.getDevDB(id)
+
+ def exportToDB(self, save=False):
+ self.db.exportToDB(self, fields=self.__exports__, save=save)
+
+ def importFromDB(self):
+ self.db.importFromDB(self, fields=self.__exports__)
def getDomain(self):
return self.controller.getDomain()
from xen.xend.XendLogging import log
from xen.xend import XendVnet
from xen.xend.XendRoot import get_component
+from xen.xend.xenstore import DBVar
from xen.xend.server import channel
from xen.xend.server.controller import CtrlMsgRcvr, Dev, DevController
"""A network device.
"""
+ # State:
+ # inherited +
+ # ./config
+ # ./mac
+ # ./be_mac
+ # ./bridge
+ # ./script
+ # ./ipaddr ?
+ #
+ # ./credit
+ # ./period
+ #
+ # ./vifctl: up/down?
+ # ./vifname
+ #
+ #
+ # Poss should have no backend state here - except for ref to backend's own tree
+ # for the device? And a status - the one we want.
+ # ./back/dom
+ # ./back/devid - id for back-end (netif_handle) - same as front/devid
+ # ./back/id - backend id (if more than one b/e per domain)
+ # ./back/status
+ # ./back/tx_shmem_frame - actually these belong in back-end state
+ # ./back/rx_shmem_frame
+ #
+ # ./front/dom
+ # ./front/devid
+ # ./front/status - need 2: one for requested, one for actual? Or drive from dev status
+ # and this is front status only.
+ # ./front/tx_shmem_frame
+ # ./front/rx_shmem_frame
+ #
+ # ./evtchn/front - here or in front/back?
+ # ./evtchn/back
+ # ./evtchn/status ?
+ # At present created by dev: but should be created unbound by front/back
+ # separately and then bound (by back)?
+
+ __exports__ = Dev.__exports__ + [
+ DBVar('config', ty='sxpr'),
+ DBVar('mac', ty='mac'),
+ DBVar('be_mac', ty='mac'),
+ DBVar('bridge', ty='str'),
+ DBVar('script', ty='str'),
+ #DBVar('ipaddr'),
+ DBVar('credit', ty='int'),
+ DBVar('period', ty='int'),
+ DBVar('vifname', ty='str'),
+ DBVar('evtchn'), #todo: export fields (renamed)
+ ]
+
def __init__(self, controller, id, config, recreate=False):
Dev.__init__(self, controller, id, config, recreate=recreate)
self.vif = int(self.id)
from xen.xend import sxp
from xen.xend.XendLogging import log
from xen.xend.XendError import XendError
+from xen.xend.xenstore import DBVar
from xen.xend.server import channel
from xen.xend.server.controller import Dev, DevController
class UsbDev(Dev):
+
+ __exports__ = Dev.__exports__ + [
+ DBVar('port', ty='int'),
+ DBVar('path', ty='str'),
+ ]
def __init__(self, controller, id, config, recreate=False):
Dev.__init__(self, controller, id, config, recreate=recreate)
setAttr(o, self.attr, val)
def getDB(self, db):
- data = getattr(db, self.path)
+ try:
+ data = getattr(db, self.path)
+ except AttributeError:
+ return None
return DBConverter.convertFromDB(data, ty=self.ty)
def setDB(self, db, val):
projects / xen.git / commitdiff